home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / fish / 726-750 / 733 / cube / cube.c < prev    next >
C/C++ Source or Header  |  1995-03-18  |  38KB  |  1,751 lines
  1. #include <cube2.h>
  2.  
  3. feed(process)
  4.  char *process;
  5. {
  6.  static int side=6,direc=0,ori=0;
  7.  
  8.    do{
  9.       switch(*process){
  10.      case 'o' :ori=1;
  11.            break;
  12.      case '2' :direc=2;
  13.            break;
  14.      case 'a' :if(ori==1)
  15.               side=3;
  16.            else
  17.               direc=1;
  18.            break;
  19.      case 'u' :if(ori==1)
  20.               side=4;
  21.            else
  22.               side=0;
  23.            break;
  24.      case 'f' :side=1;
  25.            break;
  26.      case 'l' :if(ori==1)
  27.               side=0;
  28.            else
  29.               side=2;
  30.            break;
  31.      case 'b' :side=3;
  32.            break;
  33.      case 'r' :if(ori==1)
  34.              side=5;
  35.            else
  36.              side=4;
  37.            break;
  38.      case 'd' :if(ori==1)
  39.              side=2;
  40.            else
  41.              side=5;
  42.            break;
  43.      case 'c' :if(ori==1)
  44.              side=1;
  45.            break;
  46.      default  :break;
  47.      }
  48.      Write(process);
  49.  
  50.      if(ori==1 && side<6){
  51.          orient(side);
  52.          if(single && !best)
  53.         Keywait();
  54.          ori=0;
  55.          side=6;
  56.          direc=0;
  57.      }
  58.      if(ori==0 && side<6){
  59.         rotate(side,direc);
  60.         side=6;
  61.         direc=0;
  62.         ori=0;
  63.         if(single && !best)
  64.           Keywait();
  65.         total++;
  66.      }
  67.    }while(*process++);
  68.    if(wait && !best)
  69.       Keywait();
  70. }
  71.  
  72. Keywait()
  73. {
  74.  ULONG class,menunum,menuitem;    /* copying 20 bytes. IntuiMessage is 52  */
  75.  USHORT code,id;        /* It looks about the same.  If you copy */
  76.  SHORT mousex,mousey;        /* the whole message, you still have to  */
  77.  struct Gadget *addr;        /* recopy part of the copy */
  78.  
  79.    buffer=0;
  80.    Wait(1<<Wdw->UserPort->mp_SigBit);
  81.  
  82.    while(msg=(struct IntuiMessage*)GetMsg(Wdw->UserPort))
  83.    {
  84.       class=msg->Class;
  85.       code=msg->Code;
  86.       mousex=msg->MouseX;
  87.       mousey=msg->MouseY;
  88.       addr=(struct Gadget*)msg->IAddress;
  89.  
  90.       ReplyMsg((struct IntuiMessage*)msg);
  91.  
  92.      switch(class){
  93.         case VANILLAKEY  :buffer++;
  94.                   if(buffer>BUFSIZE-1)
  95.                  buffer=BUFSIZE-1;
  96.                   key[buffer]=code;
  97.                   break;
  98.         case MENUPICK    :menunum=MENUNUM(code);
  99.                   menuitem=ITEMNUM(code);
  100.                   if(menunum==0)
  101.                  DoMenu(menuitem);
  102.                   break;
  103.        case MOUSEBUTTONS :ProcMouse(mousex,mousey);
  104.                   break;
  105.        case GADGETDOWN   :procgads(addr);
  106.                   break;
  107.        default         :break;
  108.      }
  109.    }
  110. }
  111.  
  112. Write(letter)
  113.  char *letter;
  114. {
  115.    if(best) return;
  116.  
  117.    if(*letter){
  118.       Text(rp2,letter,1);
  119.       if(rp2->cp_x>620){
  120.      yp+=9;
  121.      if(yp>61){
  122.         yp=61;
  123.         ScrollRaster(rp2,0,9,0,0,640,80);
  124.       }
  125.      Move(rp2,15,yp);
  126.       }
  127.    }
  128. }
  129.  
  130. rotate(side,direction)
  131.  int side,direction;
  132. {
  133.  int j,i;
  134.  char *source,*dest;
  135.  
  136.    if(direction==2){
  137.       direction=0;
  138.       rotate(side,direction);
  139.    }
  140.    if(!best)
  141.       (*pf[side])(direction);
  142.  
  143.    for(j=0;j<4;j++){        /* move 3 pieces per side over to next side */
  144.       source=arr1_pointer+pointer_arr[side][j];
  145.  
  146.       if(!direction){
  147.      if(j<3)
  148.         dest=arr2_pointer+pointer_arr[side][j+1];
  149.      else
  150.         dest=arr2_pointer+pointer_arr[side][j-3];
  151.       }
  152.       else{
  153.      if(j<1)
  154.         dest=arr2_pointer+pointer_arr[side][j+3];
  155.      else
  156.         dest=arr2_pointer+pointer_arr[side][j-1];
  157.       }
  158.       for(i=0;i<3;i++){
  159.      *dest++=*source++;
  160.      if(*source>15)
  161.         source-=8;
  162.      if(*dest>15)
  163.         dest-=8;
  164.       }
  165.    }
  166.    if(!direction){            /* do surface move 8 pieces */
  167.       for(j=1;j<3;j++)
  168.      arr2[side][j]=arr1[side][j+6];
  169.       for(;j<9;j++)
  170.      arr2[side][j]=arr1[side][j-2];
  171.    }
  172.    else{
  173.       for(j=1;j<7;j++)
  174.      arr2[side][j]=arr1[side][j+2];
  175.       for(;j<9;j++)
  176.      arr2[side][j]=arr1[side][j-6];
  177.    }
  178.    update(0);
  179. }
  180.  
  181. update(gadget)
  182.  int gadget;
  183. {
  184.  char *p1=&arr1[0][0];
  185.  char *p2=&arr2[0][0];
  186.  char j=0;
  187.  
  188.    if(!best && hesitate && !gadget)
  189.       Delay(hesitate);
  190.  
  191.    while(j++<60)
  192.       *p1++=*p2++;
  193.  
  194.    if(!best)
  195.       DrawHome();
  196.    if(!best && hesitate && !gadget)
  197.       Delay(hesitate);
  198.  
  199. }
  200.  
  201. orient(who)               /* if who is between 0 and 5 direction has */
  202.  int who;          /* already been selected else goto keyboard */
  203. {
  204.  int j,i,x;
  205.  char *source,*dest;
  206.  char opp,a,b,c,d,side;
  207.  
  208.       if(who>5){
  209.      do
  210.      {
  211.         if(buffer==0)
  212.            Keywait();
  213.         for(x=0;x<buffer;x++)
  214.            key[x]=key[x+1];
  215.         if(buffer>0)
  216.            buffer--;
  217.         switch(key[0]){
  218.            case'l':side=0;
  219.                break;
  220.            case'c':side=1;
  221.                break;
  222.            case'd':side=2;
  223.                break;
  224.            case'a':side=3;
  225.                break;
  226.            case'u':side=4;
  227.                break;
  228.            case'r':side=5;
  229.                break;
  230.            default:side=6;
  231.                break;
  232.         }
  233.      }while(side>5);
  234.       Write(key);
  235.       }
  236.       else
  237.      side=(char)who;
  238.  
  239.       if(!best)
  240.      (*op[side])(side);
  241.  
  242.       for(j=0;j<4;j++){               /* rotate sides all eight pieces */
  243.        source=arr1_pointer+pointer_arr[side][j];
  244.  
  245.        if(j<3)
  246.      dest=arr2_pointer+pointer_arr[side][j+1];
  247.        else
  248.      dest=arr2_pointer+pointer_arr[side][j-3];
  249.  
  250.        for(i=0;i<8;i++){
  251.       *dest++=*source++;
  252.       if(*source>15)
  253.          source-=8;
  254.       if(*dest>15)
  255.          dest-=8;
  256.     }
  257.       }
  258.       for(j=1;j<3;j++)                /* rotate one side clockwise */
  259.      arr2[side][j]=arr1[side][j+6];
  260.       for(;j<9;j++)
  261.      arr2[side][j]=arr1[side][j-2];
  262.  
  263.       opp=opposite[side];
  264.  
  265.       for(j=1;j<7;j++)                /* rotate the opposite anticlockwise */
  266.      arr2[opp][j]=arr1[opp][j+2];
  267.       for(;j<9;j++)
  268.      arr2[opp][j]=arr1[opp][j-6];
  269.  
  270.       a=orient_ptrs[side][0];          /* rotate center spots */
  271.       b=orient_ptrs[side][1];
  272.       c=orient_ptrs[side][2];
  273.       d=orient_ptrs[side][3];
  274.  
  275.       arr2[0][a]=arr1[0][d];
  276.       arr2[0][b]=arr1[0][a];
  277.       arr2[0][c]=arr1[0][b];
  278.       arr2[0][d]=arr1[0][c];
  279.  
  280.       Write(" ");
  281.       update(0);
  282.       if(dided)
  283.      ColorGads();
  284. }
  285.  
  286. StartScreens()
  287. {
  288.  int i;
  289.  
  290.    HBM=&hbm;
  291.    HRP=&hrp;
  292.  
  293.    if(!(IntuitionBase=(struct IntuitionBase*)
  294.             OpenLibrary("intuition.library",0)))   finish();
  295.    if(!(GfxBase=(struct GfxBase*)OpenLibrary("graphics.library",0)))
  296.      finish();
  297.    if(!(NewWdw.Screen=CustScr=(struct Screen*)OpenScreen(&NewCustScr)))
  298.      finish();
  299.    if(!(Wdw=(struct Window*)OpenWindow(&NewWdw)))
  300.      finish();
  301.    if(!(PrintWdw.Screen=PrtScr=(struct Screen*)OpenScreen(&PrintScr)))
  302.      finish();
  303.    if(!(Wdw2=(struct Window*)OpenWindow(&PrintWdw)))
  304.      finish();
  305.  
  306.    if(!(FontPtr=(struct TextFont*)OpenFont(&SysFont)))
  307.      finish();
  308.    SetFont(rp2,FontPtr);
  309.    SetFont(rp,FontPtr);
  310.  
  311.    SetMenuStrip(Wdw,FirstMenu);
  312.  
  313.    WVP=(struct ViewPort*)ViewPortAddress(Wdw);
  314.    LoadRGB4(WVP,colorcode,8);
  315.    WVP2=(struct ViewPort*)ViewPortAddress(Wdw2);
  316.    LoadRGB4(WVP2,colormap2,4);
  317.  
  318.    InitBitMap(HBM,DEPTH,WIDTH,HEIGHT);
  319.  
  320.    InitRastPort(HRP);
  321.  
  322.    HRP->BitMap=HBM;
  323.  
  324.    for(i=0;i<DEPTH;i++){
  325.       HBM->Planes[i]=NULL;
  326.    }
  327.    for(i=0;i<DEPTH;i++){
  328.       HBM->Planes[i]=(PLANEPTR)AllocRaster(WIDTH,HEIGHT);
  329.       if(HBM->Planes[i]==NULL)
  330.          finish();
  331.    }
  332.    SetRast(HRP,0);
  333.    SetAPen(rp,7);
  334.    SetOPen(rp,7);
  335.    SetAPen(HRP,7);
  336.    SetOPen(HRP,7);
  337.    SetAPen(rp2,2);
  338.    SetOPen(rp2,2);
  339.  
  340.    Move(rp,0,0);      /* draw border */
  341.    Draw(rp,319,0);
  342.    Draw(rp,319,139);
  343.    Draw(rp,0,139);
  344.    Draw(rp,0,0);
  345.    Move(rp,2,2);
  346.    Draw(rp,317,2);
  347.    Draw(rp,317,137);
  348.    Draw(rp,2,137);
  349.    Draw(rp,2,2);
  350. }
  351.  
  352. DrawHome()
  353. {
  354.  int a,b,x,y;
  355.  
  356.    SetRast(HRP,0);
  357.    for(x=0;x<9;x++){
  358.       SetAPen(HRP,arr1[0][x]);
  359.       a=Homeblit[0][x];
  360.       b=Homeblit[1][x];
  361.       BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  362.       SetAPen(HRP,arr1[1][x]);
  363.       a=Homeblit[2][x];
  364.       b=Homeblit[3][x];
  365.       BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  366.       SetAPen(HRP,arr1[4][x]);
  367.       a=Homeblit[4][x];
  368.       b=Homeblit[5][x];
  369.       BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  370.    }
  371.  
  372.    DrawBord.Count=32;
  373.    DrawBord.XY=HDraw;
  374.    DrawBorder(HRP,&DrawBord,40,17);
  375.  
  376.    WaitTOF();
  377.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  378. }
  379.  
  380. DrawR(direction)
  381.  int direction;
  382. {
  383.  int x,y,a,b;
  384.  
  385.    SetRast(HRP,0);
  386.    for(x=4;x<9;x++){
  387.       SetAPen(HRP,arr1[0][x]);
  388.       a=Homeblit[0][x];
  389.       b=Homeblit[1][x];
  390.       BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  391.       SetAPen(HRP,arr1[1][x]);
  392.       a=Homeblit[2][x];
  393.       b=Homeblit[3][x];
  394.       BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  395.    }
  396.  
  397.    SetAPen(HRP,arr1[0][0]);
  398.    a=Homeblit[0][0];
  399.    b=Homeblit[1][0];
  400.    BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  401.    SetAPen(HRP,arr1[1][0]);
  402.    a=Homeblit[2][0];
  403.    b=Homeblit[3][0];
  404.    BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  405.  
  406.    if(direction==1){
  407.       SetAPen(HRP,arr1[0][1]);
  408.       BltPattern(HRP,PaintLRUpper,88,15,126,36,6);
  409.       SetAPen(HRP,arr1[0][3]);
  410.      BltPattern(HRP,PaintLRUpper,78,61,116,82,6);
  411.       SetAPen(HRP,arr1[0][2]);
  412.       BltPattern(HRP,PaintLRUpper,83,38,121,59,6);
  413.       SetAPen(HRP,arr1[1][1]);
  414.       BltPattern(HRP,PaintLRLower,78,84,116,94,6);
  415.       SetAPen(HRP,arr1[1][2]);
  416.       BltPattern(HRP,PaintLRLower,84,96,122,106,6);
  417.       SetAPen(HRP,arr1[1][3]);
  418.       BltPattern(HRP,PaintLRLower,90,108,128,118,6);
  419.   }
  420.   else{
  421.       SetAPen(HRP,arr1[1][1]);
  422.       BltPattern(HRP,PaintLRUpper,88,15,126,36,6);
  423.       SetAPen(HRP,arr1[1][2]);
  424.      BltPattern(HRP,PaintLRUpper,83,38,121,59,6);
  425.       SetAPen(HRP,arr1[1][3]);
  426.       BltPattern(HRP,PaintLRUpper,78,61,116,82,6);
  427.       SetAPen(HRP,arr1[5][1]);
  428.       BltPattern(HRP,PaintLRLower,78,84,116,94,6);
  429.       SetAPen(HRP,arr1[5][2]);
  430.       BltPattern(HRP,PaintLRLower,84,96,122,106,6);
  431.       SetAPen(HRP,arr1[5][3]);
  432.       BltPattern(HRP,PaintLRLower,90,108,128,118,6);
  433.    }
  434.    for(x=0;x<9;x++){             /* do rh surface */
  435.       SetAPen(HRP,arr1[4][x]);
  436.       if(direction==1){
  437.      a=RSurfaceAnti[0][x];
  438.      b=RSurfaceAnti[1][x];
  439.       }
  440.       else{
  441.      a=RSurfaceClock[0][x];
  442.      b=RSurfaceClock[1][x];
  443.       }
  444.       BltPattern(HRP,PaintRSurface,a,b,a+10,b+33,2);
  445.    }
  446.    SetAPen(HRP,7);
  447.    x=40;
  448.    y=17;
  449.    Move(HRP,x,y);
  450.    Draw(HRP,x-24,y+24);
  451.    Draw(HRP,x-24,y+99);
  452.    Draw(HRP,x+8,y+99);
  453.    Draw(HRP,x+8,y+24);
  454.    Draw(HRP,x+32,y);
  455.    Draw(HRP,x,y);
  456.    Move(HRP,x-8,y+8);
  457.    Draw(HRP,x+50,y+8);
  458.    Move(HRP,x-16,y+16);
  459.    Draw(HRP,x+48,y+16);
  460.    Move(HRP,x-24,y+24);
  461.    Draw(HRP,x+40,y+24);
  462.    Move(HRP,x+32,y);
  463.    Draw(HRP,x+50,y);
  464.    Move(HRP,x+47,y+17);
  465.    Draw(HRP,x+40,y+24);
  466.    Draw(HRP,x+40,y+50);
  467.    Move(HRP,x+40,y+72);
  468.    Draw(HRP,x+40,y+99);
  469.    Draw(HRP,x+8,y+99);
  470.    Move(HRP,x-24,y+49);
  471.    Draw(HRP,x+40,y+49);
  472.    Move(HRP,x-24,y+74);
  473.    Draw(HRP,x+40,y+74);
  474.    Move(HRP,x+40,y+99);
  475.    Draw(HRP,x+49,y+90);
  476.            /* end of stationary part */
  477.    Move(HRP,x+37,y+66);
  478.    Draw(HRP,x+69,y+66);
  479.    Draw(HRP,x+84,y-3);
  480.    Draw(HRP,x+52,y-3);
  481.    Draw(HRP,x+37,y+66);
  482.    Draw(HRP,x+55,y+102);
  483.    Draw(HRP,x+87,y+102);
  484.    Draw(HRP,x+69,y+66);
  485.    Move(HRP,x+87,y+102);
  486.    Draw(HRP,x+102,y+33);
  487.    Draw(HRP,x+84,y-3);
  488.    Move(HRP,x+47,y+20);
  489.    Draw(HRP,x+79,y+20);
  490.    Draw(HRP,x+97,y+56);
  491.    Move(HRP,x+42,y+43);
  492.    Draw(HRP,x+74,y+43);
  493.    Draw(HRP,x+92,y+79);
  494.    Move(HRP,x+43,y+78);
  495.    Draw(HRP,x+75,y+78);
  496.    Draw(HRP,x+90,y+9);
  497.    Move(HRP,x+49,y+90);
  498.    Draw(HRP,x+81,y+90);
  499.    Draw(HRP,x+96,y+21);
  500.  
  501.    WaitTOF();
  502.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  503. }
  504.  
  505. DrawL(direction)
  506.  int direction;
  507. {
  508.  int x,y,a,b;
  509.  
  510.    SetRast(HRP,0);
  511.  
  512.    if(direction==1){
  513.       SetAPen(HRP,arr1[1][7]);
  514.       BltPattern(HRP,PaintLRUpper,24,15,62,36,6);
  515.       SetAPen(HRP,arr1[1][6]);
  516.       BltPattern(HRP,PaintLRUpper,19,38,57,59,6);
  517.       SetAPen(HRP,arr1[1][5]);
  518.       BltPattern(HRP,PaintLRUpper,14,61,49,82,6);
  519.       SetAPen(HRP,arr1[5][7]);
  520.       BltPattern(HRP,PaintLRLower,14,84,52,94,6);
  521.       SetAPen(HRP,arr1[5][6]);
  522.       BltPattern(HRP,PaintLRLower,20,96,58,106,6);
  523.       SetAPen(HRP,arr1[5][5]);
  524.       BltPattern(HRP,PaintLRLower,26,108,64,118,6);
  525.    }
  526.    else{
  527.       SetAPen(HRP,arr1[0][7]);
  528.       BltPattern(HRP,PaintLRUpper,24,15,62,36,6);
  529.       SetAPen(HRP,arr1[0][6]);
  530.       BltPattern(HRP,PaintLRUpper,19,38,57,59,6);
  531.       SetAPen(HRP,arr1[0][5]);
  532.       BltPattern(HRP,PaintLRUpper,14,61,49,82,6);
  533.       SetAPen(HRP,arr1[1][7]);
  534.       BltPattern(HRP,PaintLRLower,14,84,52,94,6);
  535.       SetAPen(HRP,arr1[1][6]);
  536.       BltPattern(HRP,PaintLRLower,20,96,58,106,6);
  537.       SetAPen(HRP,arr1[1][5]);
  538.       BltPattern(HRP,PaintLRLower,26,108,64,118,6);
  539.    }
  540.    for(x=0;x<5;x++){
  541.       SetAPen(HRP,arr1[0][x]);
  542.       a=Homeblit[0][x];
  543.       b=Homeblit[1][x];
  544.       BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  545.       SetAPen(HRP,arr1[1][x]);
  546.       a=Homeblit[2][x];
  547.       b=Homeblit[3][x];
  548.       BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  549.    }
  550.    SetAPen(HRP,arr1[0][8]);
  551.    a=Homeblit[0][8];
  552.    b=Homeblit[1][8];
  553.    BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  554.    SetAPen(HRP,arr1[1][8]);
  555.    a=Homeblit[2][8];
  556.    b=Homeblit[3][8];
  557.    BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  558.  
  559.    for(x=0;x<9;x++){
  560.       SetAPen(HRP,arr1[4][x]);
  561.       a=Homeblit[4][x];
  562.       b=Homeblit[5][x];
  563.       BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  564.    }
  565.    x=40;
  566.    y=17;
  567.    SetAPen(HRP,7);
  568.    Move(HRP,x+8,y+99);
  569.    Draw(HRP,x+8,y+24);
  570.    Draw(HRP,x+32,y);
  571.    Draw(HRP,x+96,y);
  572.    Draw(HRP,x+72,y+24);
  573.    Draw(HRP,x+72,y+99);
  574.    Draw(HRP,x+8,y+99);
  575.    Move(HRP,x+96,y);
  576.    Draw(HRP,x+96,y+75);
  577.    Draw(HRP,x+72,y+99);
  578.    Move(HRP,x+64,y);
  579.    Draw(HRP,x+40,y+24);
  580.    Draw(HRP,x+40,y+99);
  581.    Move(HRP,x+8,y+49);
  582.    Draw(HRP,x+72,y+49);
  583.    Draw(HRP,x+96,y+25);
  584.    Move(HRP,x+8,y+74);
  585.    Draw(HRP,x+72,y+74);
  586.    Draw(HRP,x+96,y+50);
  587.    Move(HRP,x+16,y+16);
  588.    Draw(HRP,x+80,y+16);
  589.    Draw(HRP,x+80,y+91);
  590.    Move(HRP,x+24,y+8);
  591.    Draw(HRP,x+88,y+8);
  592.    Draw(HRP,x+88,y+82);
  593.    Move(HRP,x+8,y+24);
  594.    Draw(HRP,x+72,y+24);
  595.    /* end of stationary part */
  596.    Move(HRP,x-27,y+66);
  597.    Draw(HRP,x+5,y+66);
  598.    Draw(HRP,x+8,y+52);
  599.    Move(HRP,x+16,y+15);
  600.    Draw(HRP,x+20,y-3);
  601.    Draw(HRP,x-12,y-3);
  602.    Draw(HRP,x-27,y+66);
  603.    Draw(HRP,x-9,y+102);
  604.    Draw(HRP,x+23,y+102);
  605.    Draw(HRP,x+20,y+99);
  606.    Move(HRP,x+5,y+66);
  607.    Draw(HRP,x+8,y+72);
  608.    Move(HRP,x+20,y-3);
  609.    Draw(HRP,x+25,y+6);
  610.    Move(HRP,x-15,y+90);
  611.    Draw(HRP,x+8,y+90);
  612.    Move(HRP,x-21,y+78);
  613.    Draw(HRP,x+8,y+78);
  614.    Move(HRP,x-22,y+43);
  615.    Draw(HRP,x+8,y+43);
  616.    Move(HRP,x-17,y+20);
  617.    Draw(HRP,x+11,y+20);
  618.    Move(HRP,x+23,y+102);
  619.    Draw(HRP,x+25,y+99);
  620.  
  621.    WaitTOF();
  622.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  623. }
  624.  
  625. DrawF(direction)
  626.  int direction;
  627. {
  628.  int x,y,a,b;
  629.  
  630.    SetRast(HRP,0);
  631.  
  632.    for(x=6;x<9;x++){
  633.       SetAPen(HRP,arr1[0][x]);
  634.       a=Homeblit[0][x];
  635.       b=Homeblit[1][x];
  636.       BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  637.       SetAPen(HRP,arr1[4][x]);
  638.       a=Homeblit[4][x];
  639.       b=Homeblit[5][x];
  640.       BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  641.    }
  642.    for(x=0;x<3;x++){
  643.       SetAPen(HRP,arr1[0][x]);
  644.       a=Homeblit[0][x];
  645.       b=Homeblit[1][x];
  646.       BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  647.       SetAPen(HRP,arr1[4][x]);
  648.       a=Homeblit[4][x];
  649.       b=Homeblit[5][x];
  650.       BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  651.    }
  652.    for(x=0;x<9;x++){
  653.       SetAPen(HRP,arr1[1][x]);
  654.       if(direction==1){
  655.      a=FSurfaceAnti[0][x];
  656.      b=FSurfaceAnti[1][x];
  657.       }
  658.       else{
  659.      a=FSurfaceClock[0][x];
  660.      b=FSurfaceClock[1][x];
  661.       }
  662.       BltPattern(HRP,PaintFSurface,a,b,a+42,b+34,6);
  663.    }
  664.    if(direction==1){
  665.       SetAPen(HRP,arr1[4][5]);
  666.       BltPattern(HRP,PaintFUpper,68,17,96,41,4);
  667.       SetAPen(HRP,arr1[4][4]);
  668.       BltPattern(HRP,PaintFUpper,90,35,118,59,4);
  669.       SetAPen(HRP,arr1[4][3]);
  670.       BltPattern(HRP,PaintFUpper,112,53,140,77,4);
  671.    }
  672.    else{
  673.       SetAPen(HRP,arr1[0][5]);
  674.       BltPattern(HRP,PaintFUpper,68,17,96,41,4);
  675.       SetAPen(HRP,arr1[0][4]);
  676.       BltPattern(HRP,PaintFUpper,90,35,118,59,4);
  677.       SetAPen(HRP,arr1[0][3]);
  678.       BltPattern(HRP,PaintFUpper,112,53,140,77,4);
  679.    }
  680.    x=40;
  681.    y=17;
  682.  
  683.    SetAPen(HRP,7);
  684.    Move(HRP,x-16,y+16);
  685.    Draw(HRP,x,y);
  686.    Draw(HRP,x+96,y);
  687.    Draw(HRP,x+80,y+16);
  688.    Draw(HRP,x+55,y+16);
  689.    Move(HRP,x+80,y+73);
  690.    Draw(HRP,x+80,y+91);
  691.    Draw(HRP,x+96,y+75);
  692.    Draw(HRP,x+96,y+59);
  693.    Move(HRP,x+96,y+48);
  694.    Draw(HRP,x+96,y);
  695.    Move(HRP,x-8,y+8);
  696.    Draw(HRP,x+25,y+8);
  697.    Move(HRP,x+46,y+8);
  698.    Draw(HRP,x+88,y+8);
  699.    Draw(HRP,x+88,y+42);
  700.    Move(HRP,x+88,y+65);
  701.    Draw(HRP,x+88,y+82);
  702.    Move(HRP,x+96,y+25);
  703.    Draw(HRP,x+83,y+38);
  704.    Move(HRP,x+64,y);
  705.    Draw(HRP,x+52,y+12);
  706.    Move(HRP,x+80,y+91);
  707.    Draw(HRP,x+56,y+91);
  708.    Move(HRP,x-2,y+91);
  709.    Draw(HRP,x-16,y+91);
  710.    Draw(HRP,x-16,y+80);
  711.    Move(HRP,x-16,y+42);
  712.    Draw(HRP,x-16,y+16);
  713.    Draw(HRP,x+16,y+16);
  714.    Draw(HRP,x+32,y);
  715.    Move(HRP,x+80,y+16);
  716.    Draw(HRP,x+80,y+35);
  717.  
  718.    Move(HRP,x-39,y+61);
  719.    Draw(HRP,x+27,y+7);
  720.    Draw(HRP,x+93,y+61);
  721.    Draw(HRP,x+27,y+115);
  722.    Draw(HRP,x-39,y+61);
  723.    Move(HRP,x+27,y+7);
  724.    Draw(HRP,x+35,y-1);
  725.    Draw(HRP,x+101,y+53);
  726.    Draw(HRP,x+93,y+61);
  727.    Move(HRP,x-17,y+43);
  728.    Draw(HRP,x+49,y+97);
  729.    Move(HRP,x+5,y+25);
  730.    Draw(HRP,x+71,y+79);
  731.    Move(HRP,x-17,y+79);
  732.    Draw(HRP,x+49,y+25);
  733.    Draw(HRP,x+57,y+17);
  734.    Move(HRP,x+5,y+97);
  735.    Draw(HRP,x+71,y+43);
  736.    Draw(HRP,x+79,y+35);
  737.  
  738.    WaitTOF();
  739.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  740. }
  741.  
  742. DrawB(direction)
  743.  int direction;
  744. {
  745.  int x,y,a,b;
  746.  
  747.    SetRast(HRP,0);
  748.  
  749.    if(direction==1){
  750.       SetAPen(HRP,arr1[0][7]);
  751.       BltPattern(HRP,PaintFUpper,80,3,108,27,4);
  752.       SetAPen(HRP,arr1[0][8]);
  753.       BltPattern(HRP,PaintFUpper,102,21,130,45,4);
  754.       SetAPen(HRP,arr1[0][1]);
  755.       BltPattern(HRP,PaintFUpper,124,39,152,63,4);
  756.    }
  757.    else{
  758.       SetAPen(HRP,arr1[4][7]);
  759.       BltPattern(HRP,PaintFUpper,80,3,108,27,4);
  760.       SetAPen(HRP,arr1[4][8]);
  761.       BltPattern(HRP,PaintFUpper,102,21,130,45,4);
  762.       SetAPen(HRP,arr1[4][1]);
  763.       BltPattern(HRP,PaintFUpper,124,39,152,63,4);
  764.    }
  765.    for(x=2;x<7;x++){
  766.       SetAPen(HRP,arr1[0][x]);
  767.       a=Homeblit[0][x];
  768.       b=Homeblit[1][x];
  769.       BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  770.  
  771.       SetAPen(HRP,arr1[4][x]);
  772.       a=Homeblit[4][x];
  773.       b=Homeblit[5][x];
  774.       BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  775.    }
  776.    SetAPen(HRP,arr1[0][0]);
  777.    a=Homeblit[0][0];
  778.    b=Homeblit[1][0];
  779.    BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  780.  
  781.    for(x=0;x<9;x++){
  782.       SetAPen(HRP,arr1[1][x]);
  783.       a=Homeblit[2][x];
  784.       b=Homeblit[3][x];
  785.       BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  786.    }
  787.    SetAPen(HRP,arr1[4][0]);
  788.    a=Homeblit[4][0];
  789.    b=Homeblit[5][0];
  790.    BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  791.  
  792.    x=40;
  793.    y=17;
  794.    SetAPen(HRP,7);
  795.    Move(HRP,x-8,y+8);
  796.    Draw(HRP,x+88,y+8);
  797.    Draw(HRP,x+88,y+83);
  798.    Draw(HRP,x+72,y+99);
  799.    Draw(HRP,x-24,y+99);
  800.    Draw(HRP,x-24,y+24);
  801.    Draw(HRP,x-8,y+8);
  802.    Move(HRP,x-16,y+16);
  803.    Draw(HRP,x+80,y+16);
  804.    Draw(HRP,x+80,y+91);
  805.    Move(HRP,x-24,y+24);
  806.    Draw(HRP,x+72,y+24);
  807.    Draw(HRP,x+72,y+99);
  808.    Move(HRP,x+24,y+8);
  809.    Draw(HRP,x+8,y+24);
  810.    Draw(HRP,x+8,y+99);
  811.    Move(HRP,x+56,y+8);
  812.    Draw(HRP,x+40,y+24);
  813.    Draw(HRP,x+40,y+99);
  814.    Move(HRP,x-24,y+49);
  815.    Draw(HRP,x+72,y+49);
  816.    Draw(HRP,x+88,y+33);
  817.    Move(HRP,x-24,y+74);
  818.    Draw(HRP,x+72,y+74);
  819.    Draw(HRP,x+88,y+58);
  820.    Move(HRP,x+72,y+24);
  821.    Draw(HRP,x+88,y+8);
  822.       /* end of stationary */
  823.    Move(HRP,x+21,y+8);
  824.    Draw(HRP,x+39,y-7);
  825.    Draw(HRP,x+57,y+8);
  826.    Move(HRP,x+88,y+33);
  827.    Draw(HRP,x+105,y+47);
  828.    Draw(HRP,x+88,y+63);
  829.    Move(HRP,x+39,y-7);
  830.    Draw(HRP,x+47,y-15);
  831.    Draw(HRP,x+75,y+8);
  832.    Move(HRP,x+88,y+19);
  833.    Draw(HRP,x+113,y+39);
  834.    Draw(HRP,x+105,y+47);
  835.    Move(HRP,x+64,y+8);
  836.    Draw(HRP,x+69,y+3);
  837.    Move(HRP,x+88,y+24);
  838.    Draw(HRP,x+91,y+21);
  839.  
  840.    WaitTOF();
  841.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  842. }
  843.  
  844. DrawU(direction)
  845.  int direction;
  846. {
  847.  int x,y,a,b;
  848.  
  849.    SetRast(HRP,0);
  850.  
  851.    for(x=2;x<7;x++){
  852.       SetAPen(HRP,arr1[1][x]);
  853.       a=Homeblit[2][x];
  854.       b=Homeblit[3][x];
  855.       BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  856.    }
  857.    SetAPen(HRP,arr1[1][0]);
  858.    a=Homeblit[2][0];
  859.    b=Homeblit[3][0];
  860.    BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  861.  
  862.    for(x=1;x<5;x++){
  863.       SetAPen(HRP,arr1[4][x]);
  864.       a=Homeblit[4][x];
  865.       b=Homeblit[5][x];
  866.       BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  867.    }
  868.    SetAPen(HRP,arr1[4][0]);
  869.    a=Homeblit[4][0];
  870.    b=Homeblit[5][0];
  871.    BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  872.  
  873.    SetAPen(HRP,arr1[4][8]);
  874.    a=Homeblit[4][8];
  875.    b=Homeblit[5][8];
  876.    BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  877.  
  878.    if(direction==1){
  879.       for(x=0;x<9;x++){
  880.      SetAPen(HRP,arr1[0][x]);
  881.      a=USurfaceAnti[0][x];
  882.      b=USurfaceAnti[1][x];
  883.      BltPattern(HRP,PaintUSurface,a,b,a+40,b+11,6);
  884.       }
  885.       SetAPen(HRP,arr1[2][1]);
  886.       BltPattern(HRP,PaintULeft,13,30,28,59,2);
  887.       SetAPen(HRP,arr1[2][2]);
  888.       BltPattern(HRP,PaintULeft,30,36,45,65,2);
  889.       SetAPen(HRP,arr1[2][3]);
  890.       BltPattern(HRP,PaintULeft,47,42,62,71,2);
  891.  
  892.       SetAPen(HRP,arr1[1][7]);
  893.       BltPattern(HRP,PaintURight,64,42,88,71,4);
  894.       SetAPen(HRP,arr1[1][8]);
  895.       BltPattern(HRP,PaintURight,90,36,114,65,4);
  896.       SetAPen(HRP,arr1[1][1]);
  897.       BltPattern(HRP,PaintURight,116,30,140,59,4);
  898.    }
  899.    else{
  900.       for(x=0;x<9;x++){
  901.     a=USurfaceClock[0][x];
  902.     b=USurfaceClock[1][x];
  903.     SetAPen(HRP,arr1[0][x]);
  904.     BltPattern(HRP,PaintUSurface,a,b,a+40,b+11,6);
  905.       }
  906.       SetAPen(HRP,arr1[1][7]);
  907.       BltPattern(HRP,PaintULeft,13,30,28,59,2);
  908.       SetAPen(HRP,arr1[1][8]);
  909.       BltPattern(HRP,PaintULeft,30,36,45,65,2);
  910.       SetAPen(HRP,arr1[1][1]);
  911.       BltPattern(HRP,PaintULeft,47,42,62,71,2);
  912.  
  913.       SetAPen(HRP,arr1[4][5]);
  914.       BltPattern(HRP,PaintURight,64,42,88,71,4);
  915.       SetAPen(HRP,arr1[4][6]);
  916.       BltPattern(HRP,PaintURight,90,36,114,65,4);
  917.       SetAPen(HRP,arr1[4][7]);
  918.       BltPattern(HRP,PaintURight,116,30,140,59,4);
  919.    }
  920.    x=40;
  921.    y=17;
  922.    SetAPen(HRP,7);
  923.    Move(HRP,x+96,y+39);
  924.    Draw(HRP,x+96,y+75);
  925.    Draw(HRP,x+72,y+99);
  926.    Draw(HRP,x-24,y+99);
  927.    Draw(HRP,x-24,y+49);
  928.    Draw(HRP,x+8,y+49);
  929.    Move(HRP,x+47,y+49);
  930.    Draw(HRP,x+72,y+49);
  931.    Draw(HRP,x+80,y+41);
  932.    Move(HRP,x-16,y+41);
  933.    Draw(HRP,x-24,y+49);
  934.    Move(HRP,x-24,y+74);
  935.    Draw(HRP,x+72,y+74);
  936.    Draw(HRP,x+96,y+50);
  937.    Move(HRP,x+8,y+49);
  938.    Draw(HRP,x+8,y+99);
  939.    Move(HRP,x+40,y+52);
  940.    Draw(HRP,x+40,y+99);
  941.    Move(HRP,x+72,y+49);
  942.    Draw(HRP,x+72,y+99);
  943.    Move(HRP,x+80,y+41);
  944.    Draw(HRP,x+80,y+91);
  945.    Move(HRP,x+88,y+40);
  946.    Draw(HRP,x+88,y+83);
  947.    /* end of stationary */
  948.    Move(HRP,x+50,y-6);
  949.    Draw(HRP,x+101,y+12);
  950.    Draw(HRP,x+23,y+30);
  951.    Draw(HRP,x-28,y+12);
  952.    Draw(HRP,x+50,y-6);
  953.    Move(HRP,x-28,y+12);
  954.    Draw(HRP,x-28,y+37);
  955.    Draw(HRP,x+23,y+55);
  956.    Draw(HRP,x+101,y+37);
  957.    Draw(HRP,x+101,y+12);
  958.    Move(HRP,x+23,y+30);
  959.    Draw(HRP,x+23,y+55);
  960.           /* inside lines */
  961.    Move(HRP,x-11,y+43);
  962.    Draw(HRP,x-11,y+18);
  963.    Draw(HRP,x+67,y);
  964.    Move(HRP,x+6,y+49);
  965.    Draw(HRP,x+6,y+24);
  966.    Draw(HRP,x+84,y+6);
  967.    Move(HRP,x+49,y+49);
  968.    Draw(HRP,x+49,y+24);
  969.    Draw(HRP,x-2,y+6);
  970.    Move(HRP,x+75,y+43);
  971.    Draw(HRP,x+75,y+18);
  972.    Draw(HRP,x+24,y);
  973.  
  974.    WaitTOF();
  975.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  976. }
  977.  
  978. DrawD(direction)
  979.  int direction;
  980. {
  981.  int a,b,x,y;
  982.  
  983.    SetRast(HRP,0);
  984.  
  985.    if(direction==1){
  986.       SetAPen(HRP,arr1[1][5]);
  987.       BltPattern(HRP,PaintULeft,13,80,28,109,2);
  988.       SetAPen(HRP,arr1[1][4]);
  989.       BltPattern(HRP,PaintULeft,30,86,45,115,2);
  990.       SetAPen(HRP,arr1[1][3]);
  991.       BltPattern(HRP,PaintULeft,47,92,62,121,2);
  992.  
  993.       SetAPen(HRP,arr1[4][3]);
  994.       BltPattern(HRP,PaintURight,64,92,88,121,4);
  995.       SetAPen(HRP,arr1[4][2]);
  996.       BltPattern(HRP,PaintURight,90,86,114,115,4);
  997.       SetAPen(HRP,arr1[4][1]);
  998.       BltPattern(HRP,PaintURight,116,80,140,109,4);
  999.    }
  1000.    else{
  1001.       SetAPen(HRP,arr1[2][7]);
  1002.       BltPattern(HRP,PaintULeft,13,80,28,110,2);
  1003.       SetAPen(HRP,arr1[2][6]);
  1004.       BltPattern(HRP,PaintULeft,30,86,45,115,2);
  1005.       SetAPen(HRP,arr1[2][5]);
  1006.       BltPattern(HRP,PaintULeft,47,92,62,121,2);
  1007.  
  1008.       SetAPen(HRP,arr1[1][5]);
  1009.       BltPattern(HRP,PaintURight,64,92,88,121,4);
  1010.       SetAPen(HRP,arr1[1][4]);
  1011.       BltPattern(HRP,PaintURight,90,86,114,115,4);
  1012.       SetAPen(HRP,arr1[1][3]);
  1013.       BltPattern(HRP,PaintURight,116,80,140,109,4);
  1014.    }
  1015.  
  1016.    for(x=0;x<9;x++){
  1017.       SetAPen(HRP,arr1[0][x]);
  1018.       a=Homeblit[0][x];
  1019.       b=Homeblit[1][x];
  1020.       BltPattern(HRP,PaintU,a,b,a+48,b+6,6);
  1021.    }
  1022.    for(x=0;x<3;x++){
  1023.       SetAPen(HRP,arr1[1][x]);
  1024.       a=Homeblit[2][x];
  1025.       b=Homeblit[3][x];
  1026.       BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  1027.    }
  1028.    for(x=6;x<9;x++){
  1029.       SetAPen(HRP,arr1[1][x]);
  1030.       a=Homeblit[2][x];
  1031.       b=Homeblit[3][x];
  1032.       BltPattern(HRP,PaintF,a,b,a+32,b+23,4);
  1033.    }
  1034.    for(x=4;x<9;x++){
  1035.       SetAPen(HRP,arr1[4][x]);
  1036.       a=Homeblit[4][x];
  1037.       b=Homeblit[5][x];
  1038.       BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  1039.    }
  1040.    SetAPen(HRP,arr1[4][0]);
  1041.    a=Homeblit[4][0];
  1042.    b=Homeblit[5][0];
  1043.    BltPattern(HRP,PaintR,a,b,a+7,b+29,2);
  1044.  
  1045.    DrawBord.Count=53;
  1046.    DrawBord.XY=DDraw;
  1047.  
  1048.    DrawBorder(HRP,&DrawBord,40,17);
  1049.  
  1050.    WaitTOF();
  1051.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  1052. }
  1053.  
  1054. Larry(direction)
  1055.  int direction;
  1056. {
  1057.  int a,b,x,y;
  1058.  
  1059.    SetRast(HRP,0);
  1060.  
  1061.    if(direction==5){
  1062.       for(x=0;x<9;x++){
  1063.      SetAPen(HRP,arr1[0][x]);
  1064.      a=USurfaceAnti[0][x];
  1065.      b=USurfaceAnti[1][x];
  1066.      BltPattern(HRP,PaintUSurface,a,b,a+40,b+11,6);
  1067.      a=LarryR[0][x];
  1068.      b=LarryR[1][x];
  1069.      SetAPen(HRP,arr1[2][x]);
  1070.      BltPattern(HRP,PaintULeft,a,b,a+15,b+29,2);
  1071.      a=LarryR[2][x];
  1072.      b=LarryR[3][x];
  1073.      SetAPen(HRP,arr1[1][x]);
  1074.      BltPattern(HRP,PaintURight,a,b,a+25,b+29,4);
  1075.       }
  1076.    }
  1077.    else{
  1078.       for(x=0;x<9;x++){
  1079.      a=USurfaceClock[0][x];
  1080.      b=USurfaceClock[1][x];
  1081.      SetAPen(HRP,arr1[0][x]);
  1082.      BltPattern(HRP,PaintUSurface,a,b,a+40,b+11,6);
  1083.  
  1084.      a=LarryL[0][x];
  1085.      b=LarryL[1][x];
  1086.      SetAPen(HRP,arr1[1][x]);
  1087.      BltPattern(HRP,PaintULeft,a,b,a+15,b+29,2);
  1088.      a=LarryL[2][x];
  1089.      b=LarryL[3][x];
  1090.      SetAPen(HRP,arr1[4][x]);
  1091.      BltPattern(HRP,PaintURight,a,b,a+25,b+29,4);
  1092.       }
  1093.    }
  1094.    SetAPen(HRP,7);
  1095.    DrawBord.Count=31;
  1096.    DrawBord.XY=OLRDraw;
  1097.    DrawBorder(HRP,&DrawBord,40,17);
  1098.  
  1099.    WaitTOF();
  1100.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  1101. }
  1102. Dura(direction)
  1103.  int direction;
  1104. {
  1105.  int a,b,x,y;
  1106.  
  1107.    SetRast(HRP,0);
  1108.  
  1109.    if(direction==2){
  1110.       for(x=0;x<9;x++){
  1111.      SetAPen(HRP,arr1[4][x]);
  1112.      a=RSurfaceAnti[0][x];
  1113.      b=RSurfaceAnti[1][x];
  1114.      BltPattern(HRP,PaintRSurface,a,b,a+10,b+33,2);
  1115.      a=DuraA[0][x];
  1116.      b=DuraA[1][x];
  1117.      SetAPen(HRP,arr1[0][x]);
  1118.      BltPattern(HRP,PaintLRUpper,a,b,a+37,b+21,6);
  1119.      a=DuraA[2][x];
  1120.      b=DuraA[3][x];
  1121.      SetAPen(HRP,arr1[1][x]);
  1122.      BltPattern(HRP,PaintLRLower,a,b,a+38,b+10,6);
  1123.       }
  1124.    }
  1125.    else{
  1126.       for(x=0;x<9;x++){
  1127.      a=RSurfaceClock[0][x];
  1128.      b=RSurfaceClock[1][x];
  1129.      SetAPen(HRP,arr1[4][x]);
  1130.      BltPattern(HRP,PaintRSurface,a,b,a+10,b+33,2);
  1131.      a=DuraA[0][x];
  1132.      b=DuraA[1][x];
  1133.      SetAPen(HRP,arr1[1][x]);
  1134.      BltPattern(HRP,PaintLRUpper,a,b,a+38,b+21,6);
  1135.      a=DuraA[2][x];
  1136.      b=DuraA[3][x];
  1137.      SetAPen(HRP,arr1[5][x]);
  1138.      BltPattern(HRP,PaintLRLower,a,b,a+38,b+10,6);
  1139.       }
  1140.    }
  1141.    SetAPen(HRP,7);
  1142.    DrawBord.Count=17;
  1143.    DrawBord.XY=OUDDraw;
  1144.    DrawBorder(HRP,&DrawBord,40,17);
  1145.  
  1146.    Move(HRP,23,37);
  1147.    Draw(HRP,119,37);
  1148.    Draw(HRP,137,73);
  1149.  
  1150.    Move(HRP,18,60);
  1151.    Draw(HRP,114,60);
  1152.    Draw(HRP,132,96);
  1153.  
  1154.    Move(HRP,19,95);
  1155.    Draw(HRP,115,95);
  1156.    Draw(HRP,130,26);
  1157.  
  1158.    Move(HRP,25,107);
  1159.    Draw(HRP,121,107);
  1160.    Draw(HRP,136,38);
  1161.  
  1162.    WaitTOF();
  1163.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  1164. }
  1165.  
  1166. Cathy(direction)
  1167.  int direction;
  1168. {
  1169.  int a,b,x,y;
  1170.  
  1171.    SetRast(HRP,0);
  1172.  
  1173.    if(direction==3){
  1174.       for(x=0;x<9;x++){
  1175.      SetAPen(HRP,arr1[1][x]);
  1176.      a=FSurfaceAnti[0][x];
  1177.      b=FSurfaceAnti[1][x];
  1178.      BltPattern(HRP,PaintFSurface,a,b,a+42,b+34,6);
  1179.      a=CathyA[0][x];
  1180.      b=CathyA[1][x];
  1181.      SetAPen(HRP,arr1[4][x]);
  1182.      BltPattern(HRP,PaintFUpper,a,b,a+29,b+24,4);
  1183.       }
  1184.    }
  1185.    else{
  1186.       for(x=0;x<9;x++){
  1187.      a=FSurfaceClock[0][x];
  1188.      b=FSurfaceClock[1][x];
  1189.      SetAPen(HRP,arr1[1][x]);
  1190.      BltPattern(HRP,PaintFSurface,a,b,a+42,b+34,6);
  1191.      a=CathyA[0][x];
  1192.      b=CathyA[1][x];
  1193.      SetAPen(HRP,arr1[0][x]);
  1194.      BltPattern(HRP,PaintFUpper,a,b,a+29,b+24,4);
  1195.       }
  1196.    }
  1197.  
  1198.    SetAPen(HRP,7);
  1199.    DrawBord.Count=25;
  1200.    DrawBord.XY=OCADraw;
  1201.    DrawBorder(HRP,&DrawBord,0,0);
  1202.  
  1203.    WaitTOF();
  1204.    BltBitMapRastPort(HBM,0,0,rp,82,3,WIDTH,HEIGHT,0xc0);
  1205. }
  1206.  
  1207. finish()
  1208. {
  1209.  int i;
  1210.  
  1211.    LoadRGB4(WVP2,colormap3,4);
  1212.    MoveScreen(Wdw2->WScreen,0,-144);
  1213.  
  1214.    for(i=0;i<DEPTH;i++){
  1215.       if(HBM->Planes[i])
  1216.      FreeRaster(HBM->Planes[i],WIDTH,HEIGHT);
  1217.    }
  1218.    if(Wdw)
  1219.       {
  1220.        if(Wdw->MenuStrip)
  1221.       ClearMenuStrip(Wdw);
  1222.        CloseWindow(Wdw);
  1223.       }
  1224.    if(Wdw2)          CloseWindow(Wdw2);
  1225.    if(CustScr)       CloseScreen(CustScr);
  1226.    if(PrtScr)        CloseScreen(PrtScr);
  1227.    if(GfxBase)       CloseLibrary((struct Library*)GfxBase);
  1228.    if(IntuitionBase) CloseLibrary((struct Library*)IntuitionBase);
  1229.    if(FontPtr)       CloseFont(FontPtr);
  1230.  
  1231.    exit();
  1232. }
  1233.  
  1234. InitGadgets()
  1235. {
  1236.  struct Gadget *g;
  1237.  UWORD visiblelines,totallines,overlap,topline,hidden;
  1238.  UWORD value;
  1239.  char Red,Green,Blue;
  1240.  
  1241.    if(done)
  1242.       return;
  1243.    if(dided)
  1244.       CloseSelect();
  1245.  
  1246.  
  1247.    SetAPen(rp,1);
  1248.    SetOPen(rp,1);
  1249.    RectFill(rp,8,40,28,50);
  1250.    SetAPen(rp,2);
  1251.    SetOPen(rp,2);
  1252.    RectFill(rp,30,40,50,50);
  1253.    SetAPen(rp,3);
  1254.    SetOPen(rp,3);
  1255.    RectFill(rp,52,40,72,50);
  1256.    SetAPen(rp,4);
  1257.    SetOPen(rp,4);
  1258.    RectFill(rp,8,55,28,65);
  1259.    SetAPen(rp,5);
  1260.    SetOPen(rp,5);
  1261.    RectFill(rp,30,55,50,65);
  1262.    SetAPen(rp,6);
  1263.    SetOPen(rp,6);
  1264.    RectFill(rp,52,55,72,65);
  1265.  
  1266.    SetAPen(rp,0);
  1267.    SetBPen(rp,7);
  1268.    Move(rp,11,98);
  1269.    Text(rp," Close ",7);
  1270.    Move(rp,19,85);
  1271.    SetAPen(rp,7);
  1272.    SetBPen(rp,0);
  1273.    Text(rp,"Delay",5);
  1274.  
  1275.     SetAPen(rp,7);
  1276.     BltPattern(rp,Box,hor[1],vert[1],hor[1]+22,vert[1]+12,4);
  1277.       col=1;
  1278.  
  1279.       value=GetRGB4(WVP->ColorMap,1);
  1280.       Blue=value&0xf;
  1281.       Green=(value >>4) &0xf;
  1282.       Red=(value >>8) &0xf;
  1283.  
  1284.       NewModifyProp(&RedGad,Wdw,NULL,AUTOKNOB|FREEHORIZ,Red<<12,
  1285.       NULL,0x1111,NULL,1L);
  1286.       NewModifyProp(&BlueGad,Wdw,NULL,AUTOKNOB|FREEHORIZ,Blue<<12,
  1287.       NULL,0x1111,NULL,1L);
  1288.       NewModifyProp(&GreenGad,Wdw,NULL,AUTOKNOB|FREEHORIZ,Green<<12,
  1289.       NULL,0x1111,NULL,1L);
  1290.       NewModifyProp(&delaygad,Wdw,NULL,AUTOKNOB|FREEHORIZ,hesitate<<10,
  1291.       NULL,0x1800,NULL,1L);
  1292.  
  1293.    AddGList(Wdw,&Gad1,(SHORT)~0,31,NULL);
  1294.    RefreshGList(&Gad1,Wdw,NULL,-1);
  1295.    PrintRGB(Red,Green,Blue);
  1296.    done=1;
  1297. }
  1298.  
  1299. DoMenu(item)
  1300.  ULONG    item;
  1301. {
  1302.    switch(item){
  1303.       case 0   :InitMouseMen();    /*mouse select */
  1304.         break;
  1305.       case 1   :InitGadgets();     /* palette */
  1306.         break;
  1307.       case 2   :clear();
  1308.         break;
  1309.       case 3   :clear();
  1310.         solve();
  1311.         break;
  1312.       case 4   :quick=1;       /* quicksolve */
  1313.         clear();
  1314.         solve();
  1315.         quick=0;
  1316.         break;
  1317.       case 5   :savecube();        /* best of 24 */
  1318.         best=quick=1;
  1319.         clear();
  1320.         Best();
  1321.         best=quick=0;
  1322.         break;
  1323.       case 6   :recall();
  1324.         break;
  1325.       case 7   :break;           /*info*/
  1326.       case 8   :finish();
  1327.         break;
  1328.       default  :break;
  1329.    }
  1330. }
  1331.  
  1332. ClosePal()
  1333. {
  1334.    RemoveGList(Wdw,&Gad1,-1);
  1335.    SetAPen(rp,0);
  1336.    SetOPen(rp,0);
  1337.    RectFill(rp,6,10,75,105);
  1338.    done=0;
  1339.    old=0;
  1340. }
  1341.  
  1342. CloseSelect()
  1343. {
  1344.    RemoveGList(Wdw,&Arrow1,-1);
  1345.    SetAPen(rp,0);
  1346.    SetOPen(rp,0);
  1347.    RectFill(rp,245,4,310,133);
  1348.    dided=0;
  1349. }
  1350.  
  1351. ProcMouse(mousex,mousey)
  1352.  SHORT mousex,mousey;
  1353. {
  1354.  char Red,Green,Blue;
  1355.  UWORD value;
  1356.  
  1357.    if(mousex>11 && mousex<68 && mousey>91 && mousey<101)  /* close palette*/
  1358.       ClosePal();
  1359.    if(mousex>245 && mousex<302 && mousey>124 && mousey<134)  /*close rotate*/
  1360.        CloseSelect();
  1361.  
  1362.    if(done){
  1363.       if(mousey>40 && mousey<51){     /* pick up color */
  1364.      if(mousex>8 && mousex<28)
  1365.         col=1;
  1366.      if(mousex>30 && mousex<50)
  1367.         col=2;
  1368.      if(mousex>52 && mousex<72)
  1369.         col=3;
  1370.      }
  1371.       if(mousey>55 && mousey<66){
  1372.      if(mousex>8 && mousex<28)
  1373.         col=4;
  1374.      if(mousex>30 && mousex<50)
  1375.         col=5;
  1376.      if(mousex>52 && mousex<72)
  1377.         col=6;
  1378.      }
  1379.      if(col!=old){
  1380.     SetAPen(rp,0);
  1381.     BltPattern(rp,Box,hor[old],vert[old],hor[old]+22,vert[old]+12,4);
  1382.     SetAPen(rp,7);
  1383.     BltPattern(rp,Box,hor[col],vert[col],hor[col]+22,vert[col]+12,4);
  1384.       }
  1385.       old=col;
  1386.  
  1387.       value=GetRGB4(WVP->ColorMap,col);
  1388.       Blue=value&0xf;
  1389.       Green=(value >>4) &0xf;
  1390.       Red=(value >>8) &0xf;
  1391.  
  1392.       NewModifyProp(&RedGad,Wdw,NULL,AUTOKNOB|FREEHORIZ,Red<<12,
  1393.       NULL,0x1111,NULL,1L);
  1394.       NewModifyProp(&BlueGad,Wdw,NULL,AUTOKNOB|FREEHORIZ,Blue<<12,
  1395.       NULL,0x1111,NULL,1L);
  1396.       NewModifyProp(&GreenGad,Wdw,NULL,AUTOKNOB|FREEHORIZ,Green<<12,
  1397.       NULL,0x1111,NULL,1L);
  1398.  
  1399.       PrintRGB(Red,Green,Blue);
  1400.    }
  1401. }
  1402.  
  1403. PrintRGB(Red,Green,Blue)
  1404.  char Red,Green,Blue;
  1405. {
  1406.  char buffy[4];
  1407.  
  1408.    SetAPen(rp,7);
  1409.    SetBPen(rp,0);
  1410.    itoa(Red,buffy,16);
  1411.    Move(rp,68,19);
  1412.    Text(rp,buffy,1);
  1413.    itoa(Green,buffy,16);
  1414.    Move(rp,68,27);
  1415.    Text(rp,buffy,1);
  1416.    itoa(Blue,buffy,16);
  1417.    Move(rp,68,35);
  1418.    Text(rp,buffy,1);
  1419.    Move(rp,58,75);
  1420.    itoa(hesitate,buffy,10);
  1421.    Text(rp,buffy,strlen(buffy));
  1422.    Text(rp," ",1);
  1423. }
  1424.  
  1425. procgads(add)
  1426.  struct Gadget *add;
  1427. {
  1428.  USHORT id;
  1429.  UBYTE,r,g,b;
  1430.  ULONG class;
  1431.  
  1432.    id=add->GadgetID;
  1433.  
  1434.       switch(id){
  1435.       case 1   :arr2[0][7]=col;
  1436.         break;
  1437.       case 2   :arr2[0][8]=col;
  1438.         break;
  1439.       case 3   :arr2[0][1]=col;
  1440.         break;
  1441.       case 4   :arr2[0][6]=col;
  1442.         break;
  1443.       case 5   :arr2[0][0]=col;
  1444.         break;
  1445.       case 6   :arr2[0][2]=col;
  1446.         break;
  1447.       case 7   :arr2[0][5]=col;
  1448.         break;
  1449.       case 8   :arr2[0][4]=col;
  1450.         break;
  1451.       case 9   :arr2[0][3]=col;
  1452.         break;
  1453.       case 10  :arr2[1][7]=col;
  1454.         break;
  1455.       case 11  :arr2[1][8]=col;
  1456.         break;
  1457.       case 12  :arr2[1][1]=col;
  1458.         break;
  1459.       case 13  :arr2[1][6]=col;
  1460.         break;
  1461.       case 14  :arr2[1][0]=col;
  1462.         break;
  1463.       case 15  :arr2[1][2]=col;
  1464.         break;
  1465.       case 16  :arr2[1][5]=col;
  1466.         break;
  1467.       case 17  :arr2[1][4]=col;
  1468.         break;
  1469.       case 18  :arr2[1][3]=col;
  1470.         break;
  1471.       case 19  :arr2[4][5]=col;
  1472.         break;
  1473.       case 20  :arr2[4][6]=col;
  1474.         break;
  1475.       case 21  :arr2[4][7]=col;
  1476.         break;
  1477.       case 22  :arr2[4][4]=col;
  1478.         break;
  1479.       case 23  :arr2[4][0]=col;
  1480.         break;
  1481.       case 24  :arr2[4][8]=col;
  1482.         break;
  1483.       case 25  :arr2[4][3]=col;
  1484.         break;
  1485.       case 26  :arr2[4][2]=col;
  1486.         break;
  1487.       case 27  :arr2[4][1]=col;
  1488.         break;
  1489.       case 28  :
  1490.       case 29  :
  1491.       case 30  :
  1492.       case 31  :do{
  1493.             if(msg=(struct IntuiMessage*)GetMsg(Wdw->UserPort)){
  1494.                class=msg->Class;
  1495.                ReplyMsg((struct Message*)msg);
  1496.             }
  1497.            r=RedStruct.HorizPot>>12;
  1498.            g=GreenStruct.HorizPot>>12;
  1499.            b=BlueStruct.HorizPot>>12;
  1500.            hesitate=delaystruct.HorizPot>>10;
  1501.            SetRGB4CM(colorcode,col,r,g,b);
  1502.            SetRGB4(WVP,col,r,g,b);
  1503.            PrintRGB(r,g,b);
  1504.           }while(class!=GADGETUP);
  1505.         break;
  1506.       case 32  :feed("f");
  1507.         break;
  1508.       case 33  :feed("af");
  1509.         break;
  1510.       case 34  :feed("2f");
  1511.         break;
  1512.       case 35  :feed("b");
  1513.         break;
  1514.       case 36  :feed("ab");
  1515.         break;
  1516.       case 37  :feed("2b");
  1517.         break;
  1518.       case 38  :feed("l");
  1519.         break;
  1520.       case 39  :feed("al");
  1521.         break;
  1522.       case 40  :feed("2l");
  1523.         break;
  1524.       case 41  :feed("r");
  1525.         break;
  1526.       case 42  :feed("ar");
  1527.         break;
  1528.       case 43  :feed("2r");
  1529.         break;
  1530.       case 44  :feed("u");
  1531.         break;
  1532.       case 45  :feed("au");
  1533.         break;
  1534.       case 46  :feed("2u");
  1535.         break;
  1536.       case 47  :feed("d");
  1537.         break;
  1538.       case 48  :feed("ad");
  1539.         break;
  1540.       case 49  :feed("2d");
  1541.         break;
  1542.       case 50  :Write(" ");
  1543.         feed("oc");
  1544.         break;
  1545.       case 51  :Write(" ");
  1546.         feed("oa");
  1547.         break;
  1548.       case 52  :Write(" ");
  1549.         feed("ou");
  1550.         break;
  1551.       case 53  :Write(" ");
  1552.         feed("od");
  1553.         break;
  1554.       case 54  :Write(" ");
  1555.         feed("or");
  1556.         break;
  1557.       case 55  :Write(" ");
  1558.         feed("ol");
  1559.         break;
  1560.       default  :break;
  1561.       }
  1562.    if(id<28)
  1563.       update(1);
  1564. }
  1565.  
  1566. InitMouseMen()
  1567. {
  1568.    if(dided)
  1569.       return;
  1570.    if(done)
  1571.       ClosePal();
  1572.  
  1573.       SetAPen(rp,7);
  1574.       SetBPen(rp,0);
  1575.       Move(rp,266,15);
  1576.       Text(rp,"TURN",4);
  1577.       Move(rp,259,96);
  1578.       SetAPen(rp,7);
  1579.       Text(rp,"ORIENT",6);
  1580.       SetAPen(rp,0);
  1581.       SetBPen(rp,7);
  1582.       Move(rp,255,131);
  1583.       Text(rp," Close ",7);
  1584.  
  1585.       AddGList(Wdw,&Arrow1,(SHORT)~0,-1,NULL);
  1586.       ColorGads();
  1587.       dided=1;
  1588. }
  1589.  
  1590. ColorGads()
  1591. {
  1592.       SetBPen(rp,0);
  1593.       Move(rp,246,25);
  1594.       SetAPen(rp,arr1[1][0]);
  1595.       Text(rp,"F",1);
  1596.       Move(rp,246,36);
  1597.       SetAPen(rp,arr1[3][0]);
  1598.       Text(rp,"B",1);
  1599.       Move(rp,246,47);
  1600.       SetAPen(rp,arr1[2][0]);
  1601.       Text(rp,"L",1);
  1602.       Move(rp,246,58);
  1603.       SetAPen(rp,arr1[4][0]);
  1604.       Text(rp,"R",1);
  1605.       Move(rp,246,69);
  1606.       SetAPen(rp,arr1[0][0]);
  1607.       Text(rp,"U",1);
  1608.       Move(rp,246,80);
  1609.       SetAPen(rp,arr1[5][0]);
  1610.       Text(rp,"D",1);
  1611.  
  1612.       DImageB.PlanePick=arr1[3][0];
  1613.       LtImageB.PlanePick=arr1[3][0];
  1614.       RtImageB.PlanePick=arr1[3][0];
  1615.  
  1616.       DImageF.PlanePick=arr1[1][0];
  1617.       LtImageF.PlanePick=arr1[1][0];
  1618.       RtImageF.PlanePick=arr1[1][0];
  1619.  
  1620.       DImageL.PlanePick=arr1[2][0];
  1621.       LtImageL.PlanePick=arr1[2][0];
  1622.       RtImageL.PlanePick=arr1[2][0];
  1623.  
  1624.       DImageR.PlanePick=arr1[4][0];
  1625.       LtImageR.PlanePick=arr1[4][0];
  1626.       RtImageR.PlanePick=arr1[4][0];
  1627.  
  1628.       DImageU.PlanePick=arr1[0][0];
  1629.       LtImageU.PlanePick=arr1[0][0];
  1630.       RtImageU.PlanePick=arr1[0][0];
  1631.  
  1632.       DImageD.PlanePick=arr1[5][0];
  1633.       LtImageD.PlanePick=arr1[5][0];
  1634.       RtImageD.PlanePick=arr1[5][0];
  1635.  
  1636.       RefreshGList(&Arrow1,Wdw,NULL,-1);
  1637. }
  1638.  
  1639. main()
  1640. {
  1641.  static char side;
  1642.  int direction,x;
  1643.  
  1644.    FirstMenu=&Menus;
  1645.  
  1646.    FuncItem[0].NextItem=&FuncItem[1];
  1647.    FuncItem[1].NextItem=&FuncItem[2];
  1648.    FuncItem[2].NextItem=&FuncItem[3];
  1649.    FuncItem[3].NextItem=&FuncItem[4];
  1650.    FuncItem[4].NextItem=&FuncItem[5];
  1651.    FuncItem[5].NextItem=&FuncItem[6];
  1652.    FuncItem[6].NextItem=&FuncItem[7];
  1653.    FuncItem[7].NextItem=&FuncItem[8];
  1654.  
  1655.    KeysItem[0].NextItem=&KeysItem[1];
  1656.    KeysItem[1].NextItem=&KeysItem[2];
  1657.    KeysItem[2].NextItem=&KeysItem[3];
  1658.    KeysItem[3].NextItem=&KeysItem[4];
  1659.    KeysItem[4].NextItem=&KeysItem[5];
  1660.    KeysItem[5].NextItem=&KeysItem[6];
  1661.    KeysItem[6].NextItem=&KeysItem[7];
  1662.  
  1663.    arr1_pointer=&arr1[0][0];
  1664.    arr2_pointer=&arr2[0][0];
  1665.  
  1666.    DrawBord.FrontPen=7;
  1667.    DrawBord.DrawMode=JAM1;
  1668.  
  1669.    pf[0]=(void*)DrawU;
  1670.    pf[1]=(void*)DrawF;
  1671.    pf[2]=(void*)DrawL;
  1672.    pf[3]=(void*)DrawB;
  1673.    pf[4]=(void*)DrawR;
  1674.    pf[5]=(void*)DrawD;
  1675.    op[0]=(void*)Larry;
  1676.    op[1]=(void*)Cathy;
  1677.    op[2]=(void*)Dura;
  1678.    op[3]=(void*)Cathy;
  1679.    op[4]=(void*)Dura;
  1680.    op[5]=(void*)Larry;
  1681.  
  1682.    StartScreens();
  1683.    DrawHome();
  1684.  
  1685.    Move(rp2,15,yp);
  1686.    direction=0;
  1687.    side=6;
  1688.  
  1689.    while(1)
  1690.    {
  1691.       Keywait();
  1692.       do
  1693.       {
  1694.        for(x=0;x<buffer;x++)
  1695.        key[x]=key[x+1];
  1696.      switch(key[0]){
  1697.         case 'u':side=UP;
  1698.              Write(key);
  1699.              break;
  1700.         case 'd':side=DOWN;
  1701.              Write(key);
  1702.              break;
  1703.         case 'l':side=LEFT;
  1704.              Write(key);
  1705.              break;
  1706.         case 'r':side=RIGHT;
  1707.              Write(key);
  1708.              break;
  1709.         case 'f':side=FRONT;
  1710.              Write(key);
  1711.              break;
  1712.         case 'b':side=BACK;
  1713.              Write(key);
  1714.              break;
  1715.         case 'o':Write(" ");
  1716.              Text(rp2,key,1);
  1717.              orient(6);
  1718.              break;
  1719.         case '2':direction=2;
  1720.              Write(key);
  1721.              break;
  1722.         case 'a':direction=1;
  1723.              Write(key);
  1724.              break;
  1725.         case 'w':wait=1;
  1726.              break;
  1727.         case '1':single=1;
  1728.              break;
  1729.         case 'p':find();
  1730.              break;
  1731.         case '5':
  1732.              best=quick=1;
  1733.              savecube();
  1734.              clear();
  1735.              Worst();
  1736.              best=quick=0;
  1737.              break;
  1738.         default :break;
  1739.         }
  1740.      if(side!=6)
  1741.         {
  1742.            rotate(side,direction);
  1743.            direction=0;
  1744.            side=6;
  1745.         }
  1746.       key[0]=0;
  1747.       }while(--buffer>0);
  1748.    }
  1749.  
  1750. }
  1751.